#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ambari_jinja2.parser
~~~~~~~~~~~~~

Implements the template parser.

:copyright: (c) 2010 by the Jinja Team.
:license: BSD, see LICENSE for more details.
"""

from ambari_jinja2 import nodes
from ambari_jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError
from ambari_jinja2.utils import next
from ambari_jinja2.lexer import describe_token, describe_token_expr


#: statements that callinto
_statement_keywords = frozenset(
  [
    "for",
    "if",
    "block",
    "extends",
    "print",
    "macro",
    "include",
    "from",
    "import",
    "set",
  ]
)
_compare_operators = frozenset(["eq", "ne", "lt", "lteq", "gt", "gteq"])


class Parser(object):
  """This is the central parsing class Jinja2 uses.  It's passed to
  extensions and can be used to parse expressions or statements.
  """

  def __init__(self, environment, source, name=None, filename=None, state=None):
    self.environment = environment
    self.stream = environment._tokenize(source, name, filename, state)
    self.name = name
    self.filename = filename
    self.closed = False
    self.extensions = {}
    for extension in environment.iter_extensions():
      for tag in extension.tags:
        self.extensions[tag] = extension.parse
    self._last_identifier = 0
    self._tag_stack = []
    self._end_token_stack = []

  def fail(self, msg, lineno=None, exc=TemplateSyntaxError):
    """Convenience method that raises `exc` with the message, passed
    line number or last line number as well as the current name and
    filename.
    """
    if lineno is None:
      lineno = self.stream.current.lineno
    raise exc(msg, lineno, self.name, self.filename)

  def _fail_ut_eof(self, name, end_token_stack, lineno):
    expected = []
    for exprs in end_token_stack:
      expected.extend(map(describe_token_expr, exprs))
    if end_token_stack:
      currently_looking = " or ".join(
        f"'{describe_token_expr(expr)}'" for expr in end_token_stack[-1]
      )
    else:
      currently_looking = None

    if name is None:
      message = ["Unexpected end of template."]
    else:
      message = [f"Encountered unknown tag '{name}'."]

    if currently_looking:
      if name is not None and name in expected:
        message.append(
          "You probably made a nesting mistake. Jinja "
          "is expecting this tag, but currently looking "
          "for %s." % currently_looking
        )
      else:
        message.append(
          f"Jinja was looking for the following tags: {currently_looking}."
        )

    if self._tag_stack:
      message.append(
        f"The innermost block that needs to be closed is '{self._tag_stack[-1]}'."
      )

    self.fail(" ".join(message), lineno)

  def fail_unknown_tag(self, name, lineno=None):
    """Called if the parser encounters an unknown tag.  Tries to fail
    with a human readable error message that could help to identify
    the problem.
    """
    return self._fail_ut_eof(name, self._end_token_stack, lineno)

  def fail_eof(self, end_tokens=None, lineno=None):
    """Like fail_unknown_tag but for end of template situations."""
    stack = list(self._end_token_stack)
    if end_tokens is not None:
      stack.append(end_tokens)
    return self._fail_ut_eof(None, stack, lineno)

  def is_tuple_end(self, extra_end_rules=None):
    """Are we at the end of a tuple?"""
    if self.stream.current.type in ("variable_end", "block_end", "rparen"):
      return True
    elif extra_end_rules is not None:
      return self.stream.current.test_any(extra_end_rules)
    return False

  def free_identifier(self, lineno=None):
    """Return a new free identifier as :class:`~ambari_jinja2.nodes.InternalName`."""
    self._last_identifier += 1
    rv = object.__new__(nodes.InternalName)
    nodes.Node.__init__(rv, "fi%d" % self._last_identifier, lineno=lineno)
    return rv

  def parse_statement(self):
    """Parse a single statement."""
    token = self.stream.current
    if token.type != "name":
      self.fail("tag name expected", token.lineno)
    self._tag_stack.append(token.value)
    pop_tag = True
    try:
      if token.value in _statement_keywords:
        return getattr(self, "parse_" + self.stream.current.value)()
      if token.value == "call":
        return self.parse_call_block()
      if token.value == "filter":
        return self.parse_filter_block()
      ext = self.extensions.get(token.value)
      if ext is not None:
        return ext(self)

      # did not work out, remove the token we pushed by accident
      # from the stack so that the unknown tag fail function can
      # produce a proper error message.
      self._tag_stack.pop()
      pop_tag = False
      self.fail_unknown_tag(token.value, token.lineno)
    finally:
      if pop_tag:
        self._tag_stack.pop()

  def parse_statements(self, end_tokens, drop_needle=False):
    """Parse multiple statements into a list until one of the end tokens
    is reached.  This is used to parse the body of statements as it also
    parses template data if appropriate.  The parser checks first if the
    current token is a colon and skips it if there is one.  Then it checks
    for the block end and parses until if one of the `end_tokens` is
    reached.  Per default the active token in the stream at the end of
    the call is the matched end token.  If this is not wanted `drop_needle`
    can be set to `True` and the end token is removed.
    """
    # the first token may be a colon for python compatibility
    self.stream.skip_if("colon")

    # in the future it would be possible to add whole code sections
    # by adding some sort of end of statement token and parsing those here.
    self.stream.expect("block_end")
    result = self.subparse(end_tokens)

    # we reached the end of the template too early, the subparser
    # does not check for this, so we do that now
    if self.stream.current.type == "eof":
      self.fail_eof(end_tokens)

    if drop_needle:
      next(self.stream)
    return result

  def parse_set(self):
    """Parse an assign statement."""
    lineno = next(self.stream).lineno
    target = self.parse_assign_target()
    self.stream.expect("assign")
    expr = self.parse_tuple()
    return nodes.Assign(target, expr, lineno=lineno)

  def parse_for(self):
    """Parse a for loop."""
    lineno = self.stream.expect("name:for").lineno
    target = self.parse_assign_target(extra_end_rules=("name:in",))
    self.stream.expect("name:in")
    iter = self.parse_tuple(with_condexpr=False, extra_end_rules=("name:recursive",))
    test = None
    if self.stream.skip_if("name:if"):
      test = self.parse_expression()
    recursive = self.stream.skip_if("name:recursive")
    body = self.parse_statements(("name:endfor", "name:else"))
    if next(self.stream).value == "endfor":
      else_ = []
    else:
      else_ = self.parse_statements(("name:endfor",), drop_needle=True)
    return nodes.For(target, iter, body, else_, test, recursive, lineno=lineno)

  def parse_if(self):
    """Parse an if construct."""
    node = result = nodes.If(lineno=self.stream.expect("name:if").lineno)
    while 1:
      node.test = self.parse_tuple(with_condexpr=False)
      node.body = self.parse_statements(("name:elif", "name:else", "name:endif"))
      token = next(self.stream)
      if token.test("name:elif"):
        new_node = nodes.If(lineno=self.stream.current.lineno)
        node.else_ = [new_node]
        node = new_node
        continue
      elif token.test("name:else"):
        node.else_ = self.parse_statements(("name:endif",), drop_needle=True)
      else:
        node.else_ = []
      break
    return result

  def parse_block(self):
    node = nodes.Block(lineno=next(self.stream).lineno)
    node.name = self.stream.expect("name").value
    node.scoped = self.stream.skip_if("name:scoped")

    # common problem people encounter when switching from django
    # to jinja.  we do not support hyphens in block names, so let's
    # raise a nicer error message in that case.
    if self.stream.current.type == "sub":
      self.fail(
        "Block names in Jinja have to be valid Python "
        "identifiers and may not contain hypens, use an "
        "underscore instead."
      )

    node.body = self.parse_statements(("name:endblock",), drop_needle=True)
    self.stream.skip_if("name:" + node.name)
    return node

  def parse_extends(self):
    node = nodes.Extends(lineno=next(self.stream).lineno)
    node.template = self.parse_expression()
    return node

  def parse_import_context(self, node, default):
    if self.stream.current.test_any(
      "name:with", "name:without"
    ) and self.stream.look().test("name:context"):
      node.with_context = next(self.stream).value == "with"
      self.stream.skip()
    else:
      node.with_context = default
    return node

  def parse_include(self):
    node = nodes.Include(lineno=next(self.stream).lineno)
    node.template = self.parse_expression()
    if self.stream.current.test("name:ignore") and self.stream.look().test(
      "name:missing"
    ):
      node.ignore_missing = True
      self.stream.skip(2)
    else:
      node.ignore_missing = False
    return self.parse_import_context(node, True)

  def parse_import(self):
    node = nodes.Import(lineno=next(self.stream).lineno)
    node.template = self.parse_expression()
    self.stream.expect("name:as")
    node.target = self.parse_assign_target(name_only=True).name
    return self.parse_import_context(node, False)

  def parse_from(self):
    node = nodes.FromImport(lineno=next(self.stream).lineno)
    node.template = self.parse_expression()
    self.stream.expect("name:import")
    node.names = []

    def parse_context():
      if self.stream.current.value in ("with", "without") and self.stream.look().test(
        "name:context"
      ):
        node.with_context = next(self.stream).value == "with"
        self.stream.skip()
        return True
      return False

    while 1:
      if node.names:
        self.stream.expect("comma")
      if self.stream.current.type == "name":
        if parse_context():
          break
        target = self.parse_assign_target(name_only=True)
        if target.name.startswith("_"):
          self.fail(
            "names starting with an underline can not " "be imported",
            target.lineno,
            exc=TemplateAssertionError,
          )
        if self.stream.skip_if("name:as"):
          alias = self.parse_assign_target(name_only=True)
          node.names.append((target.name, alias.name))
        else:
          node.names.append(target.name)
        if parse_context() or self.stream.current.type != "comma":
          break
      else:
        break
    if not hasattr(node, "with_context"):
      node.with_context = False
      self.stream.skip_if("comma")
    return node

  def parse_signature(self, node):
    node.args = args = []
    node.defaults = defaults = []
    self.stream.expect("lparen")
    while self.stream.current.type != "rparen":
      if args:
        self.stream.expect("comma")
      arg = self.parse_assign_target(name_only=True)
      arg.set_ctx("param")
      if self.stream.skip_if("assign"):
        defaults.append(self.parse_expression())
      args.append(arg)
    self.stream.expect("rparen")

  def parse_call_block(self):
    node = nodes.CallBlock(lineno=next(self.stream).lineno)
    if self.stream.current.type == "lparen":
      self.parse_signature(node)
    else:
      node.args = []
      node.defaults = []

    node.call = self.parse_expression()
    if not isinstance(node.call, nodes.Call):
      self.fail("expected call", node.lineno)
    node.body = self.parse_statements(("name:endcall",), drop_needle=True)
    return node

  def parse_filter_block(self):
    node = nodes.FilterBlock(lineno=next(self.stream).lineno)
    node.filter = self.parse_filter(None, start_inline=True)
    node.body = self.parse_statements(("name:endfilter",), drop_needle=True)
    return node

  def parse_macro(self):
    node = nodes.Macro(lineno=next(self.stream).lineno)
    node.name = self.parse_assign_target(name_only=True).name
    self.parse_signature(node)
    node.body = self.parse_statements(("name:endmacro",), drop_needle=True)
    return node

  def parse_print(self):
    node = nodes.Output(lineno=next(self.stream).lineno)
    node.nodes = []
    while self.stream.current.type != "block_end":
      if node.nodes:
        self.stream.expect("comma")
      node.nodes.append(self.parse_expression())
    return node

  def parse_assign_target(self, with_tuple=True, name_only=False, extra_end_rules=None):
    """Parse an assignment target.  As Jinja2 allows assignments to
    tuples, this function can parse all allowed assignment targets.  Per
    default assignments to tuples are parsed, that can be disable however
    by setting `with_tuple` to `False`.  If only assignments to names are
    wanted `name_only` can be set to `True`.  The `extra_end_rules`
    parameter is forwarded to the tuple parsing function.
    """
    if name_only:
      token = self.stream.expect("name")
      target = nodes.Name(token.value, "store", lineno=token.lineno)
    else:
      if with_tuple:
        target = self.parse_tuple(simplified=True, extra_end_rules=extra_end_rules)
      else:
        target = self.parse_primary()
      target.set_ctx("store")
    if not target.can_assign():
      self.fail(f"can't assign to {target.__class__.__name__.lower()!r}", target.lineno)
    return target

  def parse_expression(self, with_condexpr=True):
    """Parse an expression.  Per default all expressions are parsed, if
    the optional `with_condexpr` parameter is set to `False` conditional
    expressions are not parsed.
    """
    if with_condexpr:
      return self.parse_condexpr()
    return self.parse_or()

  def parse_condexpr(self):
    lineno = self.stream.current.lineno
    expr1 = self.parse_or()
    while self.stream.skip_if("name:if"):
      expr2 = self.parse_or()
      if self.stream.skip_if("name:else"):
        expr3 = self.parse_condexpr()
      else:
        expr3 = None
      expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno)
      lineno = self.stream.current.lineno
    return expr1

  def parse_or(self):
    lineno = self.stream.current.lineno
    left = self.parse_and()
    while self.stream.skip_if("name:or"):
      right = self.parse_and()
      left = nodes.Or(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_and(self):
    lineno = self.stream.current.lineno
    left = self.parse_not()
    while self.stream.skip_if("name:and"):
      right = self.parse_not()
      left = nodes.And(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_not(self):
    if self.stream.current.test("name:not"):
      lineno = next(self.stream).lineno
      return nodes.Not(self.parse_not(), lineno=lineno)
    return self.parse_compare()

  def parse_compare(self):
    lineno = self.stream.current.lineno
    expr = self.parse_add()
    ops = []
    while 1:
      token_type = self.stream.current.type
      if token_type in _compare_operators:
        next(self.stream)
        ops.append(nodes.Operand(token_type, self.parse_add()))
      elif self.stream.skip_if("name:in"):
        ops.append(nodes.Operand("in", self.parse_add()))
      elif self.stream.current.test("name:not") and self.stream.look().test("name:in"):
        self.stream.skip(2)
        ops.append(nodes.Operand("notin", self.parse_add()))
      else:
        break
      lineno = self.stream.current.lineno
    if not ops:
      return expr
    return nodes.Compare(expr, ops, lineno=lineno)

  def parse_add(self):
    lineno = self.stream.current.lineno
    left = self.parse_sub()
    while self.stream.current.type == "add":
      next(self.stream)
      right = self.parse_sub()
      left = nodes.Add(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_sub(self):
    lineno = self.stream.current.lineno
    left = self.parse_concat()
    while self.stream.current.type == "sub":
      next(self.stream)
      right = self.parse_concat()
      left = nodes.Sub(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_concat(self):
    lineno = self.stream.current.lineno
    args = [self.parse_mul()]
    while self.stream.current.type == "tilde":
      next(self.stream)
      args.append(self.parse_mul())
    if len(args) == 1:
      return args[0]
    return nodes.Concat(args, lineno=lineno)

  def parse_mul(self):
    lineno = self.stream.current.lineno
    left = self.parse_div()
    while self.stream.current.type == "mul":
      next(self.stream)
      right = self.parse_div()
      left = nodes.Mul(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_div(self):
    lineno = self.stream.current.lineno
    left = self.parse_floordiv()
    while self.stream.current.type == "div":
      next(self.stream)
      right = self.parse_floordiv()
      left = nodes.Div(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_floordiv(self):
    lineno = self.stream.current.lineno
    left = self.parse_mod()
    while self.stream.current.type == "floordiv":
      next(self.stream)
      right = self.parse_mod()
      left = nodes.FloorDiv(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_mod(self):
    lineno = self.stream.current.lineno
    left = self.parse_pow()
    while self.stream.current.type == "mod":
      next(self.stream)
      right = self.parse_pow()
      left = nodes.Mod(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_pow(self):
    lineno = self.stream.current.lineno
    left = self.parse_unary()
    while self.stream.current.type == "pow":
      next(self.stream)
      right = self.parse_unary()
      left = nodes.Pow(left, right, lineno=lineno)
      lineno = self.stream.current.lineno
    return left

  def parse_unary(self, with_filter=True):
    token_type = self.stream.current.type
    lineno = self.stream.current.lineno
    if token_type == "sub":
      next(self.stream)
      node = nodes.Neg(self.parse_unary(False), lineno=lineno)
    elif token_type == "add":
      next(self.stream)
      node = nodes.Pos(self.parse_unary(False), lineno=lineno)
    else:
      node = self.parse_primary()
    node = self.parse_postfix(node)
    if with_filter:
      node = self.parse_filter_expr(node)
    return node

  def parse_primary(self):
    token = self.stream.current
    if token.type == "name":
      if token.value in ("true", "false", "True", "False"):
        node = nodes.Const(token.value in ("true", "True"), lineno=token.lineno)
      elif token.value in ("none", "None"):
        node = nodes.Const(None, lineno=token.lineno)
      else:
        node = nodes.Name(token.value, "load", lineno=token.lineno)
      next(self.stream)
    elif token.type == "string":
      next(self.stream)
      buf = [token.value]
      lineno = token.lineno
      while self.stream.current.type == "string":
        buf.append(self.stream.current.value)
        next(self.stream)
      node = nodes.Const("".join(buf), lineno=lineno)
    elif token.type in ("integer", "float"):
      next(self.stream)
      node = nodes.Const(token.value, lineno=token.lineno)
    elif token.type == "lparen":
      next(self.stream)
      node = self.parse_tuple(explicit_parentheses=True)
      self.stream.expect("rparen")
    elif token.type == "lbracket":
      node = self.parse_list()
    elif token.type == "lbrace":
      node = self.parse_dict()
    else:
      self.fail(f"unexpected '{describe_token(token)}'", token.lineno)
    return node

  def parse_tuple(
    self,
    simplified=False,
    with_condexpr=True,
    extra_end_rules=None,
    explicit_parentheses=False,
  ):
    """Works like `parse_expression` but if multiple expressions are
    delimited by a comma a :class:`~ambari_jinja2.nodes.Tuple` node is created.
    This method could also return a regular expression instead of a tuple
    if no commas where found.

    The default parsing mode is a full tuple.  If `simplified` is `True`
    only names and literals are parsed.  The `no_condexpr` parameter is
    forwarded to :meth:`parse_expression`.

    Because tuples do not require delimiters and may end in a bogus comma
    an extra hint is needed that marks the end of a tuple.  For example
    for loops support tuples between `for` and `in`.  In that case the
    `extra_end_rules` is set to ``['name:in']``.

    `explicit_parentheses` is true if the parsing was triggered by an
    expression in parentheses.  This is used to figure out if an empty
    tuple is a valid expression or not.
    """
    lineno = self.stream.current.lineno
    if simplified:
      parse = self.parse_primary
    elif with_condexpr:
      parse = self.parse_expression
    else:
      parse = lambda: self.parse_expression(with_condexpr=False)
    args = []
    is_tuple = False
    while 1:
      if args:
        self.stream.expect("comma")
      if self.is_tuple_end(extra_end_rules):
        break
      args.append(parse())
      if self.stream.current.type == "comma":
        is_tuple = True
      else:
        break
      lineno = self.stream.current.lineno

    if not is_tuple:
      if args:
        return args[0]

      # if we don't have explicit parentheses, an empty tuple is
      # not a valid expression.  This would mean nothing (literally
      # nothing) in the spot of an expression would be an empty
      # tuple.
      if not explicit_parentheses:
        self.fail(
          f"Expected an expression, got '{describe_token(self.stream.current)}'"
        )

    return nodes.Tuple(args, "load", lineno=lineno)

  def parse_list(self):
    token = self.stream.expect("lbracket")
    items = []
    while self.stream.current.type != "rbracket":
      if items:
        self.stream.expect("comma")
      if self.stream.current.type == "rbracket":
        break
      items.append(self.parse_expression())
    self.stream.expect("rbracket")
    return nodes.List(items, lineno=token.lineno)

  def parse_dict(self):
    token = self.stream.expect("lbrace")
    items = []
    while self.stream.current.type != "rbrace":
      if items:
        self.stream.expect("comma")
      if self.stream.current.type == "rbrace":
        break
      key = self.parse_expression()
      self.stream.expect("colon")
      value = self.parse_expression()
      items.append(nodes.Pair(key, value, lineno=key.lineno))
    self.stream.expect("rbrace")
    return nodes.Dict(items, lineno=token.lineno)

  def parse_postfix(self, node):
    while 1:
      token_type = self.stream.current.type
      if token_type == "dot" or token_type == "lbracket":
        node = self.parse_subscript(node)
      # calls are valid both after postfix expressions (getattr
      # and getitem) as well as filters and tests
      elif token_type == "lparen":
        node = self.parse_call(node)
      else:
        break
    return node

  def parse_filter_expr(self, node):
    while 1:
      token_type = self.stream.current.type
      if token_type == "pipe":
        node = self.parse_filter(node)
      elif token_type == "name" and self.stream.current.value == "is":
        node = self.parse_test(node)
      # calls are valid both after postfix expressions (getattr
      # and getitem) as well as filters and tests
      elif token_type == "lparen":
        node = self.parse_call(node)
      else:
        break
    return node

  def parse_subscript(self, node):
    token = next(self.stream)
    if token.type == "dot":
      attr_token = self.stream.current
      next(self.stream)
      if attr_token.type == "name":
        return nodes.Getattr(node, attr_token.value, "load", lineno=token.lineno)
      elif attr_token.type != "integer":
        self.fail("expected name or number", attr_token.lineno)
      arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
      return nodes.Getitem(node, arg, "load", lineno=token.lineno)
    if token.type == "lbracket":
      priority_on_attribute = False
      args = []
      while self.stream.current.type != "rbracket":
        if args:
          self.stream.expect("comma")
        args.append(self.parse_subscribed())
      self.stream.expect("rbracket")
      if len(args) == 1:
        arg = args[0]
      else:
        arg = nodes.Tuple(args, "load", lineno=token.lineno)
      return nodes.Getitem(node, arg, "load", lineno=token.lineno)
    self.fail("expected subscript expression", self.lineno)

  def parse_subscribed(self):
    lineno = self.stream.current.lineno

    if self.stream.current.type == "colon":
      next(self.stream)
      args = [None]
    else:
      node = self.parse_expression()
      if self.stream.current.type != "colon":
        return node
      next(self.stream)
      args = [node]

    if self.stream.current.type == "colon":
      args.append(None)
    elif self.stream.current.type not in ("rbracket", "comma"):
      args.append(self.parse_expression())
    else:
      args.append(None)

    if self.stream.current.type == "colon":
      next(self.stream)
      if self.stream.current.type not in ("rbracket", "comma"):
        args.append(self.parse_expression())
      else:
        args.append(None)
    else:
      args.append(None)

    return nodes.Slice(lineno=lineno, *args)

  def parse_call(self, node):
    token = self.stream.expect("lparen")
    args = []
    kwargs = []
    dyn_args = dyn_kwargs = None
    require_comma = False

    def ensure(expr):
      if not expr:
        self.fail("invalid syntax for function call expression", token.lineno)

    while self.stream.current.type != "rparen":
      if require_comma:
        self.stream.expect("comma")
        # support for trailing comma
        if self.stream.current.type == "rparen":
          break
      if self.stream.current.type == "mul":
        ensure(dyn_args is None and dyn_kwargs is None)
        next(self.stream)
        dyn_args = self.parse_expression()
      elif self.stream.current.type == "pow":
        ensure(dyn_kwargs is None)
        next(self.stream)
        dyn_kwargs = self.parse_expression()
      else:
        ensure(dyn_args is None and dyn_kwargs is None)
        if self.stream.current.type == "name" and self.stream.look().type == "assign":
          key = self.stream.current.value
          self.stream.skip(2)
          value = self.parse_expression()
          kwargs.append(nodes.Keyword(key, value, lineno=value.lineno))
        else:
          ensure(not kwargs)
          args.append(self.parse_expression())

      require_comma = True
    self.stream.expect("rparen")

    if node is None:
      return args, kwargs, dyn_args, dyn_kwargs
    return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno)

  def parse_filter(self, node, start_inline=False):
    while self.stream.current.type == "pipe" or start_inline:
      if not start_inline:
        next(self.stream)
      token = self.stream.expect("name")
      name = token.value
      while self.stream.current.type == "dot":
        next(self.stream)
        name += "." + self.stream.expect("name").value
      if self.stream.current.type == "lparen":
        args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
      else:
        args = []
        kwargs = []
        dyn_args = dyn_kwargs = None
      node = nodes.Filter(
        node, name, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno
      )
      start_inline = False
    return node

  def parse_test(self, node):
    token = next(self.stream)
    if self.stream.current.test("name:not"):
      next(self.stream)
      negated = True
    else:
      negated = False
    name = self.stream.expect("name").value
    while self.stream.current.type == "dot":
      next(self.stream)
      name += "." + self.stream.expect("name").value
    dyn_args = dyn_kwargs = None
    kwargs = []
    if self.stream.current.type == "lparen":
      args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
    elif self.stream.current.type in (
      "name",
      "string",
      "integer",
      "float",
      "lparen",
      "lbracket",
      "lbrace",
    ) and not self.stream.current.test_any("name:else", "name:or", "name:and"):
      if self.stream.current.test("name:is"):
        self.fail("You cannot chain multiple tests with is")
      args = [self.parse_expression()]
    else:
      args = []
    node = nodes.Test(
      node, name, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno
    )
    if negated:
      node = nodes.Not(node, lineno=token.lineno)
    return node

  def subparse(self, end_tokens=None):
    body = []
    data_buffer = []
    add_data = data_buffer.append

    if end_tokens is not None:
      self._end_token_stack.append(end_tokens)

    def flush_data():
      if data_buffer:
        lineno = data_buffer[0].lineno
        body.append(nodes.Output(data_buffer[:], lineno=lineno))
        del data_buffer[:]

    try:
      while self.stream:
        token = self.stream.current
        if token.type == "data":
          if token.value:
            add_data(nodes.TemplateData(token.value, lineno=token.lineno))
          next(self.stream)
        elif token.type == "variable_begin":
          next(self.stream)
          add_data(self.parse_tuple(with_condexpr=True))
          self.stream.expect("variable_end")
        elif token.type == "block_begin":
          flush_data()
          next(self.stream)
          if end_tokens is not None and self.stream.current.test_any(*end_tokens):
            return body
          rv = self.parse_statement()
          if isinstance(rv, list):
            body.extend(rv)
          else:
            body.append(rv)
          self.stream.expect("block_end")
        else:
          raise AssertionError("internal parsing error")

      flush_data()
    finally:
      if end_tokens is not None:
        self._end_token_stack.pop()

    return body

  def parse(self):
    """Parse the whole template into a `Template` node."""
    result = nodes.Template(self.subparse(), lineno=1)
    result.set_environment(self.environment)
    return result
